home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 4 / The 640 Meg Shareware Studio CD-ROM Volume IV (Data Express)(1994).ISO / wp / ehp10.zip / AUS_2.C < prev    next >
C/C++ Source or Header  |  1993-06-19  |  43KB  |  974 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  aus_2.c                                         */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - do_textbeginn (gehe zum Textbeginn)           */
  7. /*              - do_eot (gehe zum Textende)                    */
  8. /*              - do_deleol (loesche bis Zeilenende)            */
  9. /*              - do_del_word (loesche Wort, auf dem Cursor st.)*/
  10. /*              - do_wleft (gehe Wort nach links)               */
  11. /*              - do_wright (gehe Wort nach rechts)             */
  12. /*              - do_right (gehe ein Zeichen nach rechts)       */
  13. /*              - do_left (gehe ein Zeichen nach links)         */
  14. /*              - do_up (gehe eine Zeile nach oben)             */
  15. /*              - do_down (gehe eine Zeile nach unten)          */
  16. /*              - do_settab (Tablaenge setzen)                  */
  17. /*              - do_backtab (an vorherige Tabposition springen)*/
  18. /*              - do_tab (Tab einfuegen)                        */
  19. /*              - do_pgup (Page Up ausfuehren)                  */
  20. /*              - do_pgdn (Page Down ausfuehren)                */
  21. /*              - do_open (leere Zeile vor aktueller einfuegen) */
  22. /*              - do_hopen (leere Zeile hinter aktueller efg.)  */
  23. /*              - do_newline (newline ausfuehren)               */
  24. /*              - do_delline (loesche eine Zeile)               */
  25. /*              - do_join (Zeilenverknuepfung ausfuehren)       */
  26. /*              - do_goto (Springe bestimmte Zeile an)          */
  27. /*              - do_ende (beende Editor)                       */
  28. /*              - ex_load (Loadfile ausführen)                  */
  29. /*              - do_endemit (beende Editor mit Load-File)      */
  30. /*              - quit (verlasse Editor)                        */
  31. /*              - quitmit (verlasse Editor mit Load-File)       */
  32. /****************************************************************/
  33.  
  34. #ifdef OS2
  35. #include <os2.h>
  36. #endif
  37.  
  38. #include "defs.h"
  39. #include <process.h>
  40.  
  41. extern char backupflag,highblockflag,clear_buff,bufflag;
  42. extern int schreib_file(),to_shell();
  43. extern short int letter,lastcode,aktcode,taste();
  44. extern int save_delline(),rest_delline();
  45. extern int tst_overlap(),do_find(),do_replace(),do_repfr();
  46. extern char bufflag,*loadfile,*mktemp();
  47. extern bzeil_typ *save_normal(),*save_rechteck();
  48. extern block_typ global_block,*dup_block();
  49. extern puff_typ macro[],puff_feld[];
  50. extern int ks_index;
  51. extern short int *keystack,*e_keystack,newwgetch();
  52. extern WINDOW *status;
  53. extern marker_typ marker[];
  54. #ifdef MOUSE
  55. #ifdef OS2
  56. extern int mouse_handle;
  57. extern char mouse_active;
  58. extern TID mouse_ThreadID, mouse_jn_ThreadID;
  59. #endif
  60. #endif
  61.  
  62. /* *** interne Daten und Initialisierung *** */
  63. extern char *on_off[], /* Hilfstexte */
  64.                /* fuer Togglen der globalen Flags */
  65.         helpflag;  /* Flag: Hilfstexte anzeigen       */
  66.  
  67. /*****************************************************************************
  68. *
  69. *  Funktion       Gehe zum Textbeginn (do_textbeginn)
  70. *  --------
  71. *
  72. *  Beschreibung : Der Cursor wird in die erste Textzeile bewegt.
  73. *
  74. *****************************************************************************/
  75.  
  76. void do_textbeginn()
  77. {
  78.   akt_winp->lastline = akt_winp->textline;  /* Cursorposition als letzte */
  79.   akt_winp->lastcol  = akt_winp->screencol; /* Position merken */
  80.   textbeginn();          /* Cursor intern an Textanfang positionieren */
  81.   akt_winp->ws_line = 0; /* Erste Zeile wird erste sichtbare Zeile */
  82.   show_win(W_AKT);           /* Text im Fenster neu anzeigen     */
  83. }
  84.  
  85. /*****************************************************************************
  86. *
  87. *  Funktion       Cursor an Textende (do_eot)
  88. *  --------
  89. *
  90. *  Beschreibung : Der Cursor wird an das Textende bewegt.
  91. *
  92. *****************************************************************************/
  93.  
  94. void do_eot()
  95. {
  96.   akt_winp->lastline = akt_winp->textline;  /* Cursorposition als letzte */
  97.   akt_winp->lastcol  = akt_winp->screencol; /* Position merken */
  98.   textende();  /* Cursor intern ans Textende setzen */
  99.   /* Erste Zeile wird die Zeile, die eine halbe Bildschirmlaenge ueber */
  100.   /* dem Textende liegt. Ist das Ergebnis kleiner 0 (zu wenig Zeilen), */
  101.   /* wird die erste Textzeile erste sichtbare Zeile. */
  102.   if((akt_winp->ws_line = akt_winp->maxline - akt_winp->dy/2) < 0)
  103.     akt_winp->ws_line = 0;
  104.   show_win(W_AKT); /* Fensterinhalt neu darstellen */
  105. }
  106.  
  107. /*****************************************************************************
  108. *
  109. *  Funktion       loesche bis Zeilenende (do_deleol)
  110. *  --------
  111. *
  112. *  Beschreibung : Mit der aktuellen Cursorposition beginnend, wird der Rest
  113. *                 der Zeile geloescht.
  114. *
  115. *****************************************************************************/
  116.  
  117. void do_deleol()
  118. {
  119.   if (delete_eol())  /* Zeileninhalt bis zum Zeilenende loeschen */
  120.   { /* hat das geklappt, wird die Zeile neu angezeigt */
  121.     lineout(akt_winp->textline-akt_winp->ws_line);
  122.     setz_cursor(W_AKT);  /* und der Cursor auf seine richtige Position gesetzt */
  123.   }
  124. }
  125.  
  126. /*****************************************************************************
  127. *
  128. *  Funktion       loesche Wort, auf dem der Cursor steht (do_del_word)
  129. *  --------
  130. *
  131. *  Beschreibung : Das Wort, auf dem der Cursor steht, wird geloescht.
  132. *
  133. *****************************************************************************/
  134.  
  135. void do_del_word()
  136. {
  137.   if (delete_word())  /* Wort in Textstruktur loeschen */ 
  138.   { /* hat das geklappt, Zeile neu anzeigen */
  139.     lineout(akt_winp->textline-akt_winp->ws_line);
  140.     setz_cursor(W_AKT); /* und Cursor auf seine richtige Position setzen */
  141.   }
  142. }
  143.  
  144. /*****************************************************************************
  145. *
  146. *  Funktion       Wort links (do_wleft)
  147. *  --------
  148. *
  149. *  Beschreibung : Der Cursor wird um ein Wort nach links bewegt..
  150. *
  151. *****************************************************************************/
  152.  
  153. void do_wleft()
  154. {
  155.   if (word_left()    /* Cursor ein Wort nach links */
  156.   && akt_winp->screencol < akt_winp->ws_col) /* klappte das, und steht der */
  157.   /* Cursor nun links vom Bildschirm, muss das Fenster angepasst werden. */
  158.   {
  159.     akt_winp->ws_col = akt_winp->screencol; /* Aktuelle Spalte wird erste */
  160.     sw_ohne_refresh(W_AKT); /* Fensterinhalt wird neu angezeigt */
  161.   }
  162.   setz_cursor(W_AKT);  /* Cursor auf seine richtige Position setzen */
  163. }
  164.  
  165. /*****************************************************************************
  166. *
  167. *  Funktion       Wort rechts (do_wright)
  168. *  --------
  169. *
  170. *  Beschreibung : Der Cursor wird um ein Wort nach rechts bewegt.
  171. *
  172. *****************************************************************************/
  173.  
  174. void do_wright()
  175. {
  176.   if (word_right() /* Cursor intern um ein Wort nach rechts bewegen */
  177.   && akt_winp->screencol >= akt_winp->ws_col + akt_winp->dx)
  178.   /* klappte das, und steht der Cursor dadurch rechts vom Bildschirm, */
  179.   /* so muss der Fensterinhalt angepasst werden */
  180.   {
  181.     /* Aktuelle Spalte wird zur letzten sichtbaren */
  182.     akt_winp->ws_col = akt_winp->screencol - akt_winp->dx + 1;
  183.     sw_ohne_refresh(W_AKT);  /* Fensterinhalt neu darstellen */
  184.   }
  185.   setz_cursor(W_AKT);  /* Cursor an seine richtige Position setzen */
  186. }
  187.  
  188. /*****************************************************************************
  189. *
  190. *  Funktion       fuehre Move nach rechts aus (do_right)
  191. *  --------
  192. *
  193. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach rechts bewegt.
  194. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  195. *                 das Fenster gescrollt.
  196. *
  197. *****************************************************************************/
  198.  
  199. void do_right()
  200. {
  201.   /* *** interne Daten *** */
  202.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  203.            i=0;   /* Zaehler, um wieviele Spalten gescrollt werden muss */
  204.  
  205.   nodelay (akt_winp->winp,TRUE); /* taste soll -1 bei nichtgedrueckter */
  206.   do                             /* Taste liefern */
  207.     if (right()  /* Wenn Cursor nach rechts bewegt werden konnte und */
  208.     && akt_winp->screencol >= akt_winp->ws_col+akt_winp->dx)
  209.       i++; /* Rand ueberschritten wurde, dann Scrollzaehler erhoehen */
  210.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tastenkom- */
  211.   /* bination lesen. Falls gleich der letzten, Aktion wiederholen */
  212.   lastcode = hilf; /* letzte Tastenkombination merken */
  213.   nodelay (akt_winp->winp,FALSE); /* taste soll wieder auf Tastendruck warten */
  214.   if(i>1)   /* Wenn um mehr als eine Spalte gescrollt werden soll, ist es */
  215.   { /* guenstiger, den gesamten Fensterinhalt neu zu zeigen. */
  216.     akt_winp->ws_col+=i; /* Fensterinhalt um i Spalten nach links */
  217.     sw_ohne_refresh(W_AKT);   /* Fensterinhalt neu anzeigen */
  218.   }
  219.   else if (i==1)
  220.     text_left(); /* Sonst Inhalt mit text_left um 1 nach links bewegen */
  221.   setz_cursor(W_AKT); /* Cursor an seine richtige Position setzen */
  222. }
  223.  
  224. /*****************************************************************************
  225. *
  226. *  Funktion       fuehre Move nach links aus (do_left)
  227. *  --------
  228. *
  229. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach links bewegt.
  230. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  231. *                 das Fenster gescrollt.
  232. *
  233. *****************************************************************************/
  234.  
  235. void do_left()
  236. {
  237.   /* *** interne Daten *** */
  238.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  239.            i=0;   /* Zaehler, um wieviele Spalten gescrollt werden muss */
  240.  
  241.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll /1 liefern, */
  242.   do                             /* Falls keine Taste gedrueckt ist */
  243.     if (left() /* konnte der Cursor nach links bewegt werden und geriet er */
  244.     && akt_winp->screencol < akt_winp->ws_col) /* dadurch ausserhalb des */
  245.       i++;       /* Bildschirms, wird der Scrollzaehler erhoeht. */
  246.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  247.   /* kombination einlesen. Ist die gleich der letzten, Aktion wiederholen */
  248.   lastcode = hilf; /* Letzte Tastenkombination merken */
  249.   nodelay (akt_winp->winp,FALSE); /* Funktion Taste soll wieder auf Tasten- */
  250.                   /* druck warten */
  251.   if(i>1) /* Muss um mehr als eine Spalte gescrollt werden, ist es */
  252.   {       /* guenstiger, den Fensterinhalt neu anzuzeigen */
  253.     akt_winp->ws_col-=i; /* Fensterinhalt um i Spalten nach rechts */
  254.     sw_ohne_refresh(W_AKT);   /* Fensterinhalt neu anzeigen */
  255.   }
  256.   else if (i==1) /* Muss nur um eine Spalte gescrollt werden, so kann das */
  257.     text_right(); /* mit der Funktion text_right geschehen. */
  258.   setz_cursor(W_AKT);  /* Cursor an seine richtige Position setzen */
  259. }
  260.  
  261. /*****************************************************************************
  262. *
  263. *  Funktion       fuehre Move nach oben aus (do_up)
  264. *  --------
  265. *
  266. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach oben bewegt.
  267. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  268. *                 das Fenster gescrollt.
  269. *
  270. *****************************************************************************/
  271.  
  272. void do_up()
  273. {
  274.   /* *** interne Daten und Initialisierung *** */
  275.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  276.            i=0;   /* Zaehler, wie oft gescrollt werden muss */
  277.  
  278.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll -1 liefern, wenn */
  279.   do                             /* keine Taste gedrueckt ist. */
  280.   {
  281.     if(up()  /* Wenn Cursor 1 Zeile nach oben bewegt werden konnte und */
  282.     && akt_winp->textline < akt_winp->ws_line) /* dadurch Cursor ausserhalb */
  283.       i++; /* des Fensters steht, Scrollzaehler erhoehen. */
  284.   }while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  285.   /* kombination einlesen. Falls diese gleich der letzten, Aktion wiederholen */
  286.   lastcode = hilf; /* letzte Tastenkombination merken */
  287.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll wieder auf */
  288.                   /* Tastendruck warten */
  289.   akt_winp->ws_line -= i; /* Fensterstart anpassen */
  290.   if(i>1) /* Falls um mehr als eine Zeile gescrollt werden muss, */
  291.     sw_ohne_refresh(W_AKT); /* komplettes Fenster neu anzeigen */
  292.   else if(i == 1) /* Sonst kann das Scrollen mit der Funktion text_down */
  293.     text_down(0); /* erledigt werden */
  294.   setz_cursor(W_AKT);  /* Cursor an richtige Position setzen */
  295. }
  296.  
  297. /*****************************************************************************
  298. *
  299. *  Funktion       fuehre Move nach unten aus (do_down)
  300. *  --------
  301. *
  302. *  Beschreibung : Der Cursor wird intern um ein Zeichen nach unten bewegt.
  303. *                 Bewegt sich dabei der Cursor aus dem Fenster, so wird
  304. *                 das Fenster gescrollt.
  305. *
  306. *****************************************************************************/
  307.  
  308. void do_down()
  309. {
  310.   /* *** interne Daten und Initialisierung *** */
  311.   register int hilf,  /* Zum Einlesen einer Tastenkombination */
  312.            i=0;   /* Zaehler, wie weit gescrollt werden muss */
  313.  
  314.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll -1 liefern, falls */
  315.   do                             /* keine Taste gedrueckt ist.            */
  316.   {
  317.     if(down() /* Falls Cursor um eine Zeile nach unten bewegt werden konnte */
  318.     && akt_winp->textline >= akt_winp->ws_line+akt_winp->dy) /* und Cursor */
  319.       i++; /* dadurch Fenster verlaesst, Scrollzaehler erhoehen */
  320.   }while ((hilf=taste(akt_winp->winp)) == aktcode); /* Tastenkombination */
  321.   /* einlesen. Falls diese gleich der letzten, Aktion wiederholen */
  322.   lastcode = hilf;  /* Letzte Tastenkombination merken */
  323.   nodelay (akt_winp->winp,FALSE); /* Funktion taste soll wieder auf Tasten- */
  324.                   /* druck warten */
  325.   akt_winp->ws_line += i; /* Fensterinhalt um i Zeilen nach oben */
  326.   if(i>1)  /* Falls mehr als eine Zeile gescrollt werden muss, */
  327.     sw_ohne_refresh(W_AKT); /* ganzes Fenster neu zeichnen */
  328.   else
  329.     if(i == 1)         /* Sonst Scrolling mit Funktion text_up erledigen */
  330.       text_up(0);
  331.   setz_cursor(W_AKT);       /* Cursor an richtige Position setzen */
  332. }
  333.  
  334. /*****************************************************************************
  335. *
  336. *  Funktion       Tablaenge setzen (do_settab)
  337. *  --------
  338. *
  339. *  Beschreibung : Die Tablaenge wird neu eingestellt. Ist die Eingabe leer,
  340. *                 so wird die Tablaenge nicht veraendert.
  341. *
  342. *****************************************************************************/
  343.  
  344. void do_settab()
  345. {
  346.   /* *** interne Daten *** */
  347.   char dummy[100],  /* String fuer Ausgabeaufbereitung */
  348.        num_str[6];  /* String fuer Eingabe */
  349.   int  num;         /* Ergebnis der Umwandlung von num_str in integer */
  350.  
  351.   sprintf(dummy,PROMPT_TABLEN,akt_winp->tablen);
  352.   print_stat(dummy);            /* Prompt ausgeben */
  353.   read_stat(num_str,6,GS_NUM);  /* Eingabe lesen (nur Ziffern (GS_NUM)) */
  354.   clear_stat();                 /* Statuszeile loeschen */
  355.   if((num = atoi(num_str)) > 0) /* Eingabe in Integer umwandeln */
  356.     akt_winp->tablen = num;     /* Falls Wert groesser 0, als neue Tab- */
  357.   setz_cursor(W_AKT);                /* laenge merken, Cursor positionieren */
  358. }
  359.  
  360. /*****************************************************************************
  361. *
  362. *  Funktion       eine Tabposition zurueckspringen (do_backtab)
  363. *  --------
  364. *
  365. *  Beschreibung : Abhaengig vom Autoindent- und Insertmodus wird auf den
  366. *                 Backtab-key reagiert:
  367. *                       AUTOINDENT: Tab richtet sich nach darueberliegender
  368. *                                   Zeile.
  369. *                       INSERT:     feste Tabweite zurueckspringen
  370. *
  371. *****************************************************************************/
  372.  
  373. void do_backtab()
  374. {
  375.   /* *** interne Daten *** */
  376.   register int diff,  /* Entfernung zur naechsten Tabgrenze (nur benutzt, */
  377.               /* falls Autoindent abgeschaltet) */
  378.            nsc;   /* Spaltennummer der Tabgrenze links des Cursors */
  379.  
  380.   if(akt_winp->autoindflag && up()) /* Falls Autoindent eingeschaltet, und */
  381.   { /* Cursor eine Zeile nach oben bewegt werden konnte, */
  382.     /* naechste Tabgrenze links vom Cursor nsc zuweisen. */
  383.     if ((nsc = akt_winp->tablen * ((akt_winp->screencol-1)/akt_winp->tablen))
  384.     >= fastll (akt_winp->alinep->text)) /* Ist nsc hinter Zeilenende, */
  385.       akt_winp->screencol = nsc; /* screencol auf nsc setzen. */
  386.     else                  /* Ist nsc in der Zeile, dann ein Wort nach links */
  387.       word_left();
  388.     down();   /* Anschliessed in die urspruengliche Zeile zurueckkehren */
  389.   }
  390.   else  /* Falls Autoindent ausgeschaltet ist, Entfernung zur naechsten */
  391.     /* links vom Cursor gelegenen Tab-Grenze berechnen */
  392.     for(diff = (akt_winp->screencol-1)%akt_winp->tablen + 1;diff>0;diff--)
  393.       left(); /* So oft dann den Cursor nach links bewegen */
  394.  
  395.   if(akt_winp->ws_col > akt_winp->screencol) /* Falls Cursor dadurch */
  396.   {                                          /* links vom Fenster, */
  397.     akt_winp->ws_col = akt_winp->screencol;  /* Aktuelle Spalte zur ersten */
  398.     sw_ohne_refresh(W_AKT); /* sichtbaren Spalte machen, Fensterinhalt neu zeigen */
  399.   }
  400.   setz_cursor(W_AKT); /* Cursor an richtige Position setzen */
  401. }
  402.  
  403. /*****************************************************************************
  404. *
  405. *  Funktion       Tab einfuegen (do_tab)
  406. *  --------
  407. *
  408. *  Beschreibung : Abhaengig vom Autoindent- und Insertmodus wird auf den
  409. *                 Tab-key reagiert:
  410. *                       AUTOINDENT: Tab richtet sich nach darueberliegender
  411. *                                   Zeile.
  412. *                       INSERT:     Spaces werden eingefuegt.
  413. *
  414. *****************************************************************************/
  415.  
  416. void do_tab()
  417. {
  418.   /* *** interne Daten und Initialisierung *** */
  419.   register int old_sc,  /* Zwischenspeicher fuer Cursorspalte */
  420.            dsc = 0, /* Entfernung, die durch Tab geskipt wird */
  421.            anz_ins; /* Anzahl der eingefuegten Blanks */
  422.  
  423.   if(akt_winp->autoindflag && up()) /* Bei Autoindent eine Zeile hoch */
  424.   {
  425.     old_sc = akt_winp->screencol; /* falls das klappt, Spalte merken */
  426.     word_right();                 /* ein Wort nach rechts */
  427.     down();                       /* und wieder in alte Zeile */
  428.     dsc = akt_winp->screencol - old_sc; /* "Streckenlaenge" merken */
  429.     akt_winp->screencol = old_sc; /* Screencol wieder auf alten Wert */
  430.   }
  431.   /* falls normaler Tab oder bei autoindent nicht weitergegangen werden */
  432.   if(!dsc) /* konnte, Entfernung zur naechsten festen Tabgrenze berechnen */
  433.     dsc = akt_winp->tablen - akt_winp->screencol%akt_winp->tablen;
  434.   if(akt_winp->insflag) /* Falls Insert-Mode aktiv, dsc Blanks einfuegen */
  435.   {
  436.     if((anz_ins = insert(dsc)) < dsc) /* Falls weniger als dsc chars ein- */
  437.     { /* gefuegt werden konnten, eingefuegte Zeichen loeschen */
  438.       mdelete(anz_ins);
  439.       print_err("Zeile zu lang! ");  /* und Fehlermeldung ausgeben */
  440.       return;
  441.     }
  442.     else
  443.       while(anz_ins--)   /* Eingefuegte Zeichen mit Blanks belegen */
  444.     enter_char(' ');
  445.   }
  446.   else  /* Falls im Overwrite-Modus, dsc Zeichen nach rechts bewegen */
  447.     while(dsc--)
  448.       right();
  449.   if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol)
  450.   { /* Falls Cursor ausserhalb des Fensters, Fensterinhalt anpassen */
  451.     /* Aktuelle Spalte soll in der Mitte des Fensters stehen */
  452.     akt_winp->ws_col = akt_winp->screencol - akt_winp->dx/2;
  453.     sw_ohne_refresh(W_AKT); /* Anschliessend Fensterinhalt neu anzeigen */
  454.   }
  455.   setz_cursor(W_AKT);  /* Cursor an seine Position plazieren */
  456. }
  457.  
  458. /*****************************************************************************
  459. *
  460. *  Funktion       Page Up ausfuehren (do_pgup)
  461. *  --------
  462. *
  463. *  Beschreibung : Der interne Cursor wird um eine Seite hochbewegt.
  464. *                 Dann wird die Fensterposition angepasst und der
  465. *                 Fensterinhalt erneut dargestellt.
  466. *
  467. *****************************************************************************/
  468.  
  469. void do_pgup()
  470. {
  471.   /* *** interne Daten *** */
  472.   register int hilf;  /* Zum Einlesen einer Tastenkombination */
  473.  
  474.   nodelay (akt_winp->winp,TRUE);  /* Funktion taste soll -1 liefern, */
  475.   do                              /* falls keine Taste gedrueckt ist */
  476.     if((akt_winp->ws_line -= screen_up()) < 0) /* Neuen Fensterstart */
  477.       akt_winp->ws_line = 0;                   /* berechnen          */
  478.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  479.   /* kombination lesen. Ist sie gleich der letzten, Aktion wiederholen */
  480.   lastcode = hilf; /* zuletzt gelesene Tastenkombination merken */
  481.   nodelay (akt_winp->winp,FALSE); /* Fkt. Taste soll auf Taste warten */
  482.   show_win(W_AKT);                 /* Text im Fenster neu anzeigen     */
  483. }
  484.  
  485. /*****************************************************************************
  486. *
  487. *  Funktion       Page Down ausfuehren (do_pgdn)
  488. *  --------
  489. *
  490. *  Beschreibung : Der interne Cursor wird um eine Seite nach unten bewegt.
  491. *                 Dann wird die Fensterposition angepasst und der
  492. *                 Fensterinhalt erneut dargestellt. Steht der Cursor in der
  493. *                 letzten Textzeile, so wird diese in die Bildschirmmitte
  494. *                 plaziert.
  495. *
  496. *****************************************************************************/
  497.  
  498. void do_pgdn()
  499. {
  500.   /* *** interne Daten *** */
  501.   register int hilf;  /* Zum Einlesen einer Tastenkombination */
  502.  
  503.   nodelay (akt_winp->winp,TRUE);  /* Funktion taste soll -1 liefern, */
  504.   do                              /* falls keine Taste gedrueckt ist */
  505.     akt_winp->ws_line += screen_down(); /* Cursor um eine Seite nach unten */
  506.                       /* bewegen und Fensterstart anpassen */
  507.   while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  508.   /* kombinationo einlesen. Falls gleich der letzten, Aktion wiederholen */
  509.   lastcode = hilf;                    /* letzte Tastenkombination merken */
  510.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll auf Taste warten */
  511.   show_win(W_AKT);                  /* Text im Fenster neu anzeigen     */
  512. }
  513.  
  514. /*****************************************************************************
  515. *
  516. *  Funktion       leere Zeile vor aktueller einfuegen (do_open)
  517. *  --------
  518. *
  519. *  Beschreibung : vor der aktuellen Zeile wird eine Zeile eingefuegt, die dann
  520. *                 zur aktuellen wird.
  521. *
  522. *****************************************************************************/
  523.  
  524. void do_open()
  525. {
  526.   /* *** interne Daten *** */
  527.   int indpos,  /* Zur Berechnung, wie weit eingerueckt werden muss */
  528.       old_sc;  /* Zwischenspeicher fuer alte Cursorspalte          */
  529.  
  530.   if(akt_winp->maxline < MAX_ANZ_LINES-1) /* Nur neue Zeile einfuegen, */
  531.   {      /* wenn dadurch maximale Zeilenzahl nicht ueberschritten wird */
  532.     check_buff();  /* evtl. noch im Puffer befindliche Daten in Text kopieren */
  533.     if(akt_winp->maxline >= 0)   /* Enthaelt Text mindestens eine Zeile ? */
  534.     {                     /* Ja, dann muss auf Autoindent geachtet werden */
  535.       if(akt_winp->autoindflag)             /* Autoindent eingeschaltet ? */
  536.     indpos = akt_winp->alinep->text ? strspn(akt_winp->alinep->text," ")
  537.                     : 0; /* Ja, dann die Anzahl */
  538.               /* fuehrender Blanks in der aktuellen Zeile ermitteln */
  539.       akt_winp->alinep = akt_winp->alinep->prev; /* da up nicht vor die erste */
  540.       akt_winp->textline--; /* Zeile geht, muss man "zu Fuss" eine Zeile hoch.    */
  541.       old_sc = akt_winp->screencol;    /* Zeile wird dahinter eingefuegt, */
  542.       akt_winp->screencol = MAXLENGTH; /* also screencol aufs Ende        */
  543.       koppel_line(ADAPT_COORS);  /* Zeile in Textstruktur einfuegen      */
  544.       if (akt_winp->autoindflag) /* Bei Autoindent stellt man sich ueber */
  545.     akt_winp->screencol = indpos; /* den Anfang der Zeile darunter   */
  546.       else
  547.     akt_winp->screencol = old_sc;
  548.  
  549.       if(akt_winp->screencol < akt_winp->ws_col /* Wenn Cursor links oder */
  550.       || akt_winp->ws_col+akt_winp->dx < akt_winp->screencol) /* rechts   */
  551.       { /* ausserhalb des Fensters steht, wird die aktuelle Spalte zur    */
  552.     akt_winp->ws_col = akt_winp->screencol; /* ersten sichtbaren      */
  553.     sw_ohne_refresh(W_AKT);  /* Fensterinhalt neu anzeigen                 */
  554.       }
  555.       else /* Steht Cursor innerhalb des Fensters, wird mit text_down eine */
  556.     text_down(akt_winp->textline - akt_winp->ws_line); /* Zeile auf    */
  557.     }   /* dem Bildschirm eingefuegt */
  558.     else  /* War der Text leer, wird lediglich eine neue Zeile erzeugt */
  559.       koppel_line(IGNORE_COORS); /* Marker und lastpos sind im leeren Text egal */
  560.     setz_cursor(W_AKT);      /* Cursor an richtige Position setzen */
  561.   }
  562.   else                /* Wuerde der Text durch eine weitere Zeile zu lang, */
  563.     print_err(T_SIZE_ERRTEXT);     /* Fehlermeldung ausgeben */
  564. }
  565.  
  566. /*****************************************************************************
  567. *
  568. *  Funktion       leere Zeile hinter aktueller einfuegen (do_hopen)
  569. *  --------
  570. *
  571. *  Beschreibung : hinter der aktuellen Zeile wird eine Zeile eingefuegt, die dann
  572. *                 zur aktuellen wird.
  573. *
  574. *****************************************************************************/
  575.  
  576. void do_hopen()
  577. {
  578.   /* *** interne Daten und Initialisierung *** */
  579.   int hilfs  = akt_winp->shellflag, /* Zwischenspeicher fuer shellflag */
  580.       hilfi  = akt_winp->insflag,   /* Zwischenspeicher fuer insflag   */
  581.       old_sc = akt_winp->screencol; /* Zwischenspeicher fuer screencol */
  582.  
  583.   check_buff(); /* evtl. noch im Puffer stehende Daten in Text uebertragen */
  584.   akt_winp->screencol = fastll(akt_winp->alinep->text); /* Ans Zeilenende */
  585.   akt_winp->insflag = TRUE; /* so wird auf jeden Fall neue Zeile eingefuegt */
  586.   akt_winp->shellflag = FALSE;    /* keine Zeile an Shell schicken */
  587.   if(!do_newline())    /* Zeile einfuegen und testen, ob das geklappt hat */
  588.     akt_winp->screencol = old_sc; /* Falls nein, Cursor wieder in alte Spalte */
  589.   akt_winp->insflag = hilfi;      /* Insflag und shellflag restaurieren */
  590.   akt_winp->shellflag = hilfs;
  591.   setz_cursor(W_AKT);         /* Damit Flags in Kopf richtig angezeigt werden */
  592. }
  593.  
  594. /*****************************************************************************
  595. *
  596. *  Funktion       newline ausfuehren (do_newline)
  597. *  --------
  598. *
  599. *  Ergebnis     :
  600. *                   Typ          : int
  601. *                   Wertebereich : TRUE,FALSE
  602. *                   Bedeutung    : TRUE: Es konnte noch eine Zeile eingefuegt
  603. *                                  werden.
  604. *
  605. *  Beschreibung : Die aktuelle Zeile wird evtl. gesplittet und in der
  606. *                 Textstruktur eine neue Zeile angelegt. Falls dabei der
  607. *                 Cursor aus dem Fenster laeuft, wird der Bildschirm ge-
  608. *                 scrollt.
  609. *
  610. *****************************************************************************/
  611.  
  612. int do_newline()
  613. {
  614.   /* *** interne Daten und Initialisierung *** */
  615.   char *cmd,           /* An SHELL zu uebergebende Kommandozeile */
  616.        swflag = FALSE; /* Zeigt an, ob Fensterinhalt neu gezeigt werden muss */
  617.   int  old_sc;         /* Zwischenspeicher fuer Cursorspalte */
  618.  
  619.   if (akt_winp->insflag) /* Falls im Insert-Mode, dann */
  620.     if (new_line())      /* Zeile einfuegen und testen, ob das geklappt hat */
  621.     { /* Testen, ob Fenster gescrollt werden muss */
  622.       if (akt_winp->textline-akt_winp->ws_line >= akt_winp->dy)
  623.       {
  624.     akt_winp->ws_line++; /* wenn ja, Nummer der ersten Zeile + 1 */
  625.     text_up(0);          /* und Fensterinhalt scrollen */
  626.       }
  627.       else /* Wenn nicht gescrollt werden muss, eine Zeile einfuegen */
  628.     text_down(akt_winp->textline-akt_winp->ws_line);
  629.       if(akt_winp->autoindflag)    /* Wenn Autoindent aktiv ist, */
  630.       {                            /* neue Zeile korrekt einruecken */
  631.     indent_line();             /* Dann wird getestet, ob der Cursor */
  632.     if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol /* rechts */
  633.     || akt_winp->screencol < akt_winp->ws_col) /* oder links vom */
  634.     {                                          /* Fenster steht  */
  635.       akt_winp->ws_col = akt_winp->screencol;  /* Wenn ja, dann wird */
  636.       swflag = TRUE; /* aktuelle Spalte zur ersten sichtbaren, und */
  637.     }            /* das Fenster wird als neu zu zeichnend markiert */
  638.     else         /* Wenn der Cursor innerhalb des Fensters blieb, */
  639.       lineout(akt_winp->textline - akt_winp->ws_line); /* dann muss */
  640.       } /* nur die Zeile neu gezeigt werden */
  641.     }
  642.     else /* Wenn keine neue Zeile eingefuegt werden konnte, dann */
  643.     {
  644.       print_err (T_SIZE_ERRTEXT); /* Fehlermeldung ausgeben */
  645.       return (FALSE);             /* und Funktion abbrechen */
  646.     }
  647.   else                  /* OVERWRITE-modus */
  648.   {
  649.     if (!down())        /* Cursor eine Zeile nach unten bewegen */
  650.       return(FALSE);    /* Klappte das nicht, Funktion abbrechen */
  651.     else                /* Klappte es, Cursor an Zeilenanfang stellen */
  652.       bol();
  653.     if (akt_winp->textline-akt_winp->ws_line >= akt_winp->dy) /* Testen, */
  654.     { /* ob Cursor nach unten aus dem Fenster gegangen ist */
  655.       akt_winp->ws_line++; /* Wenn ja, Fensterstart anpassen */
  656.       text_up(0);          /* und Fensterinhalt scrollen */
  657.     }
  658.   }
  659.   /* Wenn Cursor am linken Rand stehen kann, (kein Autoindent oder kein */
  660.   /* Insert-Mode) dann muss die erste Spalte sichtbar sein              */
  661.   if((!akt_winp->autoindflag || !akt_winp->insflag) && akt_winp->ws_col)
  662.   { /* Ist das nicht so, wird der Fensterinhalt als neu zu zeichnend   */
  663.     swflag = TRUE;        /* markiert und Spalte 0 als erste sichtbare */
  664.     akt_winp->ws_col = 0; /* markiert. */
  665.   }
  666.  
  667.      /*** Testen, ob Zeile an SHELL uebergeben werden muss *** */
  668.  
  669.   if(akt_winp->shellflag && (cmd = akt_winp->alinep->prev->text))
  670.   { /* Das ist der Fall, wenn shellflag gesetzt ist und die aufgespaltene */
  671.     old_sc = akt_winp->screencol; /* Zeile nicht leer ist. Dann wird die  */
  672.     up();  /* Cursorspalte gemerkt und der Cursor eine Zeile hochbewegt.  */
  673.     if(akt_winp->maxline < MAX_ANZ_LINES-1) /* Platz fuer weitere Zeile ? */
  674.     {
  675.       koppel_line(ADAPT_COORS);  /* Zeile einfuegen, so dass Shellausgabe */
  676.                  /* nicht mit evtl. Zeilenrest vermischt wird */
  677.       if(to_shell(cmd))   /* nur wenn auch etwas eingefuegt werden konnte */
  678.       {                    /* eine Zeile nach Ende der Ausgabe anspringen */
  679.     gotox(akt_winp->block.e_line+1); /* Steht Cursor anschliessend    */
  680.     /* unter dem Fenster, Fensterposition anpassen */
  681.     if(akt_winp->textline >= akt_winp->ws_line + akt_winp->dy)
  682.       akt_winp->ws_line = akt_winp->textline - akt_winp->dy/2;
  683.     swflag = TRUE;        /* veraenderter Bildschirminhalt */
  684.       }
  685.       else                     /* Wenn keine Shellausgabe vorhanden ist, */
  686.     del_line(ADAPT_COORS); /* eingefuegte Leerzeile wieder loeschen  */
  687.     }
  688.     else                       /* konnte keine Zeile mehr einfuegen */
  689.       pe_or(T_SIZE_ERRTEXT);   /* also Fehlermeldung ausgeben */
  690.     akt_winp->screencol = old_sc; /* Cursorspalte restaurieren */
  691.   }
  692.   if(swflag)            /* Wenn Fensterinhalt als zu restaurierend gekenn- */
  693.     sw_ohne_refresh(W_AKT);  /* zeichnet, Fensterinhalt neu anzeigen */
  694.   setz_cursor(W_AKT);        /* Cursor an richtige Position setzen */
  695.   return (TRUE);
  696. }
  697.  
  698. /*****************************************************************************
  699. *
  700. *  Funktion       loesche eine Zeile (do_delline)
  701. *  --------
  702. *
  703. *  Beschreibung : Die aktuelle Zeile wird aus der Textstruktur geloescht
  704. *                 und der Bildschirm aktualisiert.
  705. *
  706. *****************************************************************************/
  707.  
  708. void do_delline()
  709. {
  710.   /* *** interne Daten und Initialisierung *** */
  711.   register int i=0,  /* Zaehler fuer geloeschte Zeilen */
  712.            hilf, /* Zum Einlesen einer Tastenkombination */
  713.            ret;  /* Zwischenspeicher fuer Rueckgabewert von del_line */
  714.  
  715.   nodelay (akt_winp->winp,TRUE); /* Funktion taste soll -1 liefern, falls */
  716.   do                             /* keine Taste gedrueckt ist. */
  717.   {
  718.     save_delline();              /* zu loeschende Zeile abspeichern */
  719.     if((ret = del_line(ADAPT_COORS)) != NO_LINE_DEL) /* Zeile loeschen, */
  720.       i++;    /* Rueckgabewert von del_line merken und Zaehler anpassen */
  721.   }while ((hilf=taste(akt_winp->winp)) == aktcode); /* Naechste Tasten- */
  722.   /* kombination einlesen. Falls gleich der letzten, Aktion wiederholen */
  723.   lastcode = hilf; /* Zuletzt gelesene Tastenkombination merken */
  724.   nodelay (akt_winp->winp,FALSE); /* Fkt. taste soll auf Taste warten */
  725.  
  726.   if(i == 1 && ret == LAST_LINE_DEL) /* Wenn nur die letzte Zeile geloescht */
  727.   {  /* wurde, dann diese Zeile auf Bildschirm loeschen, Rahmen reparieren */
  728.     wmove(akt_winp->winp,akt_winp->maxline+2-akt_winp->ws_line,1);
  729.     wclrtoeol(akt_winp->winp);
  730.     mvwaddch(akt_winp->winp,akt_winp->maxline+2-akt_winp->ws_line,akt_winp->dx + 1,REST_CHAR);
  731.     setz_cursor(W_AKT);
  732.   }
  733.   if(i) /* Wenn mindestens eine Zeile geloescht wurde, testen ob Cursor */
  734.   {     /* nach oben aus dem Fenster gewandert ist.                     */
  735.     if(akt_winp->textline < akt_winp->ws_line) /* Wenn ja, dann warum ? */
  736.       if(akt_winp->textline == -1) /* Wenn wegen "Text leer", dann      */
  737.     akt_winp->ws_line = 0;     /* ws_line auf 0 setzen              */
  738.       else                         /* Sonst aktuelle Zeile zur ersten   */
  739.     akt_winp->ws_line = akt_winp->textline; /* sichtbaren machen    */
  740.     show_win(W_AKT); /* Anschliessend Fensterinhalt anzeigen                 */
  741.   }
  742. }
  743.  
  744. /*****************************************************************************
  745. *
  746. *  Funktion       Zeilenverknuepfung ausfuehren (do_join)
  747. *  --------
  748. *
  749. *  Beschreibung : Mittels der Funktion join werden die aktuelle und die
  750. *                 nachfolgende Zeile verknuepft. Falls dabei ein Fehler
  751. *                 auftritt, wird gegebenfalls eine Fehlermeldung ausgegeben.
  752. *
  753. *****************************************************************************/
  754.  
  755. void do_join()
  756. {
  757.   /* *** interne Daten *** */
  758.   char first_of_2nd_is_blank,
  759.        first_is_blank;
  760.  
  761.   if (akt_winp->maxline > 0      /* Geht nur, wenn mehr als eine Zeile */
  762.   && akt_winp->alinep->next != akt_winp->dummyp) /* und aktuelle Z. */
  763.   {                              /* nicht letzte Zeile ist */
  764.     first_of_2nd_is_blank = (!akt_winp->alinep->next->text ||
  765.               *(akt_winp->alinep->next->text) == ' ');
  766.     first_is_blank = !akt_winp->alinep->text;
  767.     do_eol();            /* Zunächst ein Zeichen rechts vom Zeilenende */
  768.     if (first_of_2nd_is_blank)  /* Ist erstes Zeichen der nächsten Zeile kein */
  769.       do_right();        /* Blank, dann nicht nach rechts. */
  770.     switch (join(ADAPT_COORS))   /* Verknuepfung ausfuehren, Ergebnis testen */
  771.     {
  772.       case J_TOOLONG : print_err(L_SIZE_ERRTEXT); /* Zeile wurde zu lang, */
  773.                break;                     /* Meldung ausgeben     */
  774.       case J_OK      : if(first_of_2nd_is_blank) /* Falls Blank, dann */
  775.              do_del_word();   /* Text ranziehen */
  776.                else               /* Sonst Blank einfügen */
  777.                { /* geht gut, da join() mindestens ein Zeichen */
  778.              /* Aber nur einfügen, wenn erste Zeile nicht
  779.                 leer war ! */
  780.              if (!first_is_blank)
  781.              {
  782.                insert(1);  /* Platz am Zeilenende läßt */
  783.                enter_char(' ');
  784.              }
  785.                }
  786.                show_win(W_AKT); /* Alles OK, Fensterinhalt neu anzeigen */
  787.     }
  788.   }
  789. }
  790.  
  791. /*****************************************************************************
  792. *
  793. *  Funktion       Springe bestimmte Zeile an (do_goto)
  794. *  --------
  795. *
  796. *  Beschreibung : Nach Einlesen einer Zeilennummer wird, falls moeglich,
  797. *                 die aktuelle Zeile entsprechend gesezt.
  798. *
  799. *****************************************************************************/
  800.  
  801. void do_goto()
  802. {
  803.   /* *** interne Daten *** */
  804.   char number[10]; /* String fuer einzulesende Zeilennummer */
  805.   int numi;        /* Eingelesene Zeilennummer als Integer  */
  806.  
  807.   print_stat(PROMPT_LINENUMB);
  808.   read_stat(number,9,GS_NUM);     /* Zeilennummer einlesen (nur Ziffern) */
  809.   clear_stat();                   /* Statuszeile wieder loeschen */
  810.  
  811.   /* String in int wandeln und Bereichspruefung durchfuehren */
  812.   if((numi = atoi(number)) > 0 && numi <= akt_winp->maxline+1)
  813.   { /* Wenn Zeilennummer im korrekten Bereich, dann */
  814.     akt_winp->lastline = akt_winp->textline; /* aktuelle Position als  */
  815.     akt_winp->lastcol = akt_winp->screencol; /* letzte Position merken */
  816.     gotox(numi-1);                     /* gewuenschte Zeile anspringen */
  817.     if((akt_winp->ws_line = numi-akt_winp->dy/2) < 0) /* Zeile in der Mitte */
  818.       akt_winp->ws_line = 0; /* plazieren. Falls das nicht geht, weil       */
  819.       /* Zeilennummer zu klein, ws_line entsprechend anpassen               */
  820.     sw_ohne_refresh(W_AKT);  /* Fensterinhalt neu anzeigen */
  821.   }
  822.   setz_cursor(W_AKT);        /* Cursor an richtige Position setzen */
  823. }
  824.  
  825. /*****************************************************************************
  826. *
  827. *  Funktion       beende editor (do_ende)
  828. *  --------
  829. *
  830. *  Beschreibung : Nach einer Rueckfrage wird der Editor evtl. beendet.
  831. *                 Nach dem letzten Speichern geaenderte Files werden ab-
  832. *                 gespeichert. Danach wird das Config-File geupdatet.
  833. *
  834. *****************************************************************************/
  835.  
  836. void do_ende()
  837. {
  838.   /* Meldung ausgeben und J/N-Abfrage vornehmen */
  839.   if(ja_nein(PROMPT_WARNSAVE))
  840.     /* Will User wirklich beenden, alle geaenderten Dateien sichern */
  841.     if(save_all() || ja_nein(PROMPT_EXITANYWY)) /* Bei Fehler Abfrage */
  842.     { /* Wenn Speichern klappte, oder Abfrage mit J beantwortet wurde, */
  843.       write_config();  /* wird die Konfigurationsdatei gespeichert, */
  844.       alles_frei();    /* aller reservierter Speicher freigegeben   */
  845.       ende(0, TRUE);   /* und der Editor beendet.                   */
  846.     }
  847.   setz_cursor(W_AKT); /* Will der User doch nicht abbrechen, wird der Cursor */
  848. }                /* an seine korrekte Position gesetzt. */
  849.  
  850. /******************************************************************************
  851. *
  852. * Funktion     : Loadfile ausführen (ex_load)
  853. * --------------
  854. *
  855. * Beschreibung : Das in der globalen Variablen spezifizierte loadfile wird
  856. *                ausgeführt. Dazu wird der Inhalt der Datei in eine tempo-
  857. *                räre Datei kopiert (mit system("copy...")). An die temporäre
  858. *                Datei wird eine Zeile angehängt, die "exit" enthält.
  859. *                Dann wird command.com über spawnlp aufgerufen, als Parameter
  860. *                wird "<"+<Name der temporären Datei> übergeben. Die Shell
  861. *                liest also die Kommandos aus der temporären Datei und wird
  862. *                anschließend durch exit beendet. Anschließend wird die
  863. *                tempräre Datei gelöscht und der Return-Wert von spawnlp
  864. *                behandelt.
  865. *
  866. ******************************************************************************/
  867.  
  868. void ex_load()
  869. {
  870.   int sys_ret;      /* Rückgabewert der system-Funktion */
  871.   int ex_st;
  872.  
  873.   if(access(loadfile,4) == 0)  /* Lese-Zugriff auf Loadfile ? */
  874.   {
  875.     sys_ret = system(loadfile);
  876.     if(sys_ret == -1)
  877.       fprintf(stderr,NO_LOAD_ERRTEXT);  /* Falls system nicht klappte, */
  878.     ex_st=sys_ret;       /* Fehlermeldung ausgeben und ende */
  879.   }
  880.   else
  881.   {
  882.     fprintf(stderr,"Loadfile %s nicht gefunden !\n",loadfile);
  883.     ex_st=1;
  884.   }
  885. #ifdef MOUSE
  886. #ifdef OS2
  887.   mouse_active = FALSE;
  888.   DosWaitThread (&mouse_ThreadID, DCWW_WAIT);
  889.   if (mouse_jn_ThreadID) /* Wurde schon einmal ja_nein aufgerufen? */
  890.     DosWaitThread (&mouse_jn_ThreadID, DCWW_WAIT);
  891. #else
  892.   set_mouse_int(0); /* Mausroutine maskieren */
  893. #endif
  894. #endif
  895. #ifndef OS2
  896.   *(long*)(27*4) = old_int; /* Vektor des Break-Interruptes restaurieren */
  897. #endif
  898.   exit (ex_st);
  899. }
  900.  
  901. /*****************************************************************************
  902. *
  903. *  Funktion       beende editor mit loadfile (do_endemit)
  904. *  --------
  905. *
  906. *  Beschreibung : Nach einer Rueckfrage wird der Editor evtl. beendet.
  907. *                 Nach dem letzten Speichern geaenderte Files werden ab-
  908. *                 gespeichert. Danach wird das Config-File geupdatet
  909. *                 und das Load-File ausgefuehrt.
  910. *
  911. *****************************************************************************/
  912.  
  913. void do_endemit()
  914. {
  915.   /* Funktion der Abfragen s.o. */
  916.   if(ja_nein(PROMPT_WARNSAVE))
  917.     if(save_all() || ja_nein(PROMPT_EXITANYWY))
  918.     {
  919.       write_config();  /* Konfigurationsdatei abspeichern */
  920.       alles_frei();    /* Saemtlichen reservierten Speicherplatz freigeben */
  921.       clear();         /* Bildschirm loeschen */
  922.       refresh();
  923.       endwin();        /* Curses "abschalten" */
  924.       ex_load();       /* Loadfile ausführen, Programm wird beendet */
  925.     }
  926.   setz_cursor(W_AKT); /* Will User doch nicht beenden, Cursor wieder plazieren */
  927. }
  928.  
  929.  
  930. /*****************************************************************************
  931. *
  932. *  Funktion       verlasse editor (quit)
  933. *  --------
  934. *
  935. *  Beschreibung : Das Programm wird (nach Rueckfrage) beendet.
  936. *
  937. *****************************************************************************/
  938.  
  939. void quit()
  940. {
  941.   if (ja_nein (PROMPT_WARNQUIT))
  942.   { /* Sicherheitsabfrage */
  943.     write_config();  /* Wenn User wirklich beenden will, Config-Datei */
  944.     alles_frei();    /* speicher, Speicherplatz freigeben, */
  945.     ende(0, TRUE);   /* Editor beenden */
  946.   }
  947.   setz_cursor(W_AKT);     /* Falls doch nicht beendet werden soll, Cursor */
  948. }                    /* wieder an richtige Position stellen */
  949.  
  950. /*****************************************************************************
  951. *
  952. *  Funktion       quit mit Ausfuehren des load-Files (quitmit)
  953. *  --------
  954. *
  955. *  Beschreibung : Nach einer positiv beantworteten Rueckfrage wird die
  956. *                 Config-Datei gespeichert und der Editor mit dem
  957. *                 Load-File ueberlagert.
  958. *
  959. *****************************************************************************/
  960.  
  961. void quitmit()
  962. {
  963.   if (ja_nein (PROMPT_WARNQUIT))
  964.   { /* Sicherheitsabfrage */
  965.     write_config(); /* Falls mit J geantwortet wurde, Config-Datei */
  966.     alles_frei();   /* speichern, Speicherplatz freigeben, */
  967.     clear();        /* Bildschirm loeschen */
  968.     refresh();
  969.     endwin();       /* Curses "abschalten" */
  970.     ex_load();
  971.   }
  972.   setz_cursor(W_AKT); /* Wollte User doch nicht beenden, Cursor plazieren */
  973. }
  974.